# llm_integration.py
import asyncio
import base64
import io
from typing import AsyncGenerator, Dict, Any, List
import re
from typing import Optional, Tuple, List, Dict, Any
import zhipuai
from models.database import get_db_connection
import mysql.connector
from PIL import Image
import jieba
from collections import Counter


class ZhipuAIClient:
    """智谱AI客户端 - 增强数据检索版本"""

    def _extract_chinese_keywords(self, text: str, top_k=3) -> List[str]:
        words = jieba.lcut(text)
        # 过滤停用词、单字、数字
        filtered = [w for w in words if len(w) > 1 and not w.isdigit() and w not in self.stop_words]
        return [word for word, _ in Counter(filtered).most_common(top_k)]

    def _parse_user_query(self, user_query: str) -> Dict[str, Any]:
        """从用户问题中提取结构化查询条件"""
        query = user_query.strip()
        conditions = {
            'good_id': None,
            'good_name_keywords': [],
            'stock_min': None,
            'sales_min': None,
            'review_rate_min': None,
            'price_min': None,
            'price_max': None,
            'original_query': query
        }

        # 改进版：支持“商品100007”、“商品ID:100007”、“100007”等格式
        id_patterns = [
            # 综合模式：同时处理所有情况
            r'(?:商品\s*[iI]?[dD]?\s*[为:：]?\s*)?\b(\d{6})\b'
        ]
        for pattern in id_patterns:
            match = re.search(pattern, query)
            if match:
                conditions['good_id'] = int(match.group(1))
                break

        # 2. 提取价格区间（支持“200-1000”、“200到1000”、“200~1000”）
        price_patterns = [
            r'(\d+(?:\.\d+)?)\s*[-~到至]\s*(\d+(?:\.\d+)?)',
            r'价格[在介于]*\s*(\d+(?:\.\d+)?)\s*[-~到至]\s*(\d+(?:\.\d+)?)'
        ]
        for pattern in price_patterns:
            p_match = re.search(pattern, query)
            if p_match:
                low, high = float(p_match.group(1)), float(p_match.group(2))
                conditions['price_min'] = min(low, high)
                conditions['price_max'] = max(low, high)
                break

        # 3. 提取库存 > X
        stock_match = re.search(r'库存[大于超过高于不少于至少]?(\d+)\s*(?:以上|以上的产品)?', query)
        if stock_match:
            conditions['stock_min'] = int(stock_match.group(1))

        # 4. 提取销量 > X
        sales_match = re.search(r'销量[大于超过高于不少于至少]?(\d+)', query)
        if sales_match:
            conditions['sales_min'] = int(sales_match.group(1))

        # 5. 提取好评率（支持 80%、90%、0.85 等）
        review_match = re.search(r'好评率[大于超过高于不少于至少]?(\d{1,3})\s*%', query)
        if review_match:
            rate = int(review_match.group(1)) / 100.0
            conditions['review_rate_min'] = min(rate, 1.0)
        else:
            # 支持小数形式：如“好评率0.85以上”
            review_dec_match = re.search(r'好评率[大于超过高于不少于至少]?(\d\.\d{1,2})', query)
            if review_dec_match:
                conditions['review_rate_min'] = float(review_dec_match.group(1))

        # 6. 提取商品名称关键词（排除通用词）
        # 简单做法：移除已知条件词后，剩余部分作为关键词
        clean_query = re.sub(r'\d{6}', '', query)  # 移除ID
        clean_query = re.sub(r'\d+\s*[-~到至]\s*\d+', '', clean_query)  # 移除价格区间
        clean_query = re.sub(r'[库存销量好评率价格][大于超过高于不少于至少\d%\.\-到~]+', '', clean_query)
        clean_query = re.sub(r'[介绍推荐查找查询搜索有没有给我一款]', '', clean_query)
        clean_query = re.sub(r'[商品ID编号]', '', clean_query)
        keywords = [w.strip() for w in clean_query.split() if len(w.strip()) > 1 and not w.isdigit()]

        # 过滤停用词
        stop_words = {'的', '了', '吗', '呢', '吧', '请', '一下', '这款', '这个', '那个', '有哪些', '有什么'}
        keywords = [k for k in keywords if k not in stop_words]

        if keywords:
            conditions['good_name_keywords'] = keywords

        return conditions

    def __init__(self, api_key: str):
        self.client = zhipuai.ZhipuAI(api_key=api_key)
        self.db = get_db_connection()  # ✅ 初始化数据库连接
        if not self.db:
            raise Exception("数据库连接失败")

    def _query_products_by_keyword(self, keyword, limit=5):
        if not keyword:
            return []
        connection = get_db_connection()
        if not connection:
            return []
        cursor = None
        try:
            cursor = connection.cursor(dictionary=True)
            keywords = keyword.split()
            like_conditions = " OR ".join(["(good_name LIKE %s OR good_description LIKE %s)"] * len(keywords))
            params = [f"%{k}%" for k in keywords for _ in range(2)]
            query = f"""
                SELECT 
                    good_id, 
                    good_name, 
                    good_description, 
                    good_sell_price, 
                    good_number,
                    good_sell_num,  -- 确保包含销量字段
                    good_positive_review_rate  -- 确保包含好评率字段
                FROM goods
                WHERE ({like_conditions}) AND good_number > 0
                LIMIT %s
            """
            params.append(limit)
            cursor.execute(query, params)
            result = cursor.fetchall()
            return result
        except Exception as e:
            print(f"关键词搜索错误: {e}")
            return []
        finally:
            if cursor:
                cursor.close()
            if connection:
                connection.close()

    def _query_top_selling_products(self, limit: int = 5) -> List[Dict[str, Any]]:
        """查询销量最高的商品"""
        connection = get_db_connection()
        if not connection:
            return []
        cursor = None
        try:
            cursor = connection.cursor(dictionary=True)
            query = """
                SELECT good_id, good_name, good_number, good_sell_num,
                       good_positive_review_rate, good_purchase_price,
                       good_sell_price, good_description
                FROM goods
                ORDER BY good_sell_num DESC
                LIMIT %s
            """
            cursor.execute(query, (limit,))
            return cursor.fetchall()
        except mysql.connector.Error as e:
            print(f"数据库查询错误 (top selling): {e}")
            return []
        finally:
            if cursor:
                cursor.close()
            if connection:
                connection.close()

    def _query_products_by_conditions(self, conditions: Dict[str, Any], limit: int = 10) -> List[Dict[str, Any]]:
        """根据结构化条件查询商品"""
        connection = get_db_connection()
        if not connection:
            return []

        cursor = None
        try:
            cursor = connection.cursor(dictionary=True)

            base_fields = """
                good_id, good_name, good_number, good_sell_num,
                good_positive_review_rate, good_purchase_price,
                good_sell_price, good_description
            """
            query = f"SELECT {base_fields} FROM goods WHERE 1=1"
            params = []

            # 商品ID 精确匹配
            if conditions.get('good_id') is not None:
                query += " AND good_id = %s"
                params.append(conditions['good_id'])

            # 商品名称关键词（OR 匹配）
            if conditions.get('good_name_keywords'):
                keyword_clause = " AND ("
                for i, kw in enumerate(conditions['good_name_keywords']):
                    if i > 0:
                        keyword_clause += " OR "
                    keyword_clause += "(good_name LIKE %s OR good_description LIKE %s)"
                    params.extend([f"%{kw}%", f"%{kw}%"])
                keyword_clause += ")"
                query += keyword_clause

            # 库存
            if conditions.get('stock_min') is not None:
                query += " AND good_number >= %s"
                params.append(conditions['stock_min'])

            # 销量
            if conditions.get('sales_min') is not None:
                query += " AND good_sell_num >= %s"
                params.append(conditions['sales_min'])

            # 好评率
            if conditions.get('review_rate_min') is not None:
                query += " AND good_positive_review_rate >= %s"
                params.append(conditions['review_rate_min'])

            # 价格区间
            if conditions.get('price_min') is not None:
                query += " AND good_sell_price >= %s"
                params.append(conditions['price_min'])
            if conditions.get('price_max') is not None:
                query += " AND good_sell_price <= %s"
                params.append(conditions['price_max'])

            # 排序：优先销量，其次好评率
            query += " ORDER BY good_sell_num DESC, good_positive_review_rate DESC LIMIT %s"
            params.append(limit)

            cursor.execute(query, params)
            return cursor.fetchall()

        except mysql.connector.Error as e:
            print(f"条件查询数据库错误: {e}")
            return []
        finally:
            if cursor:
                cursor.close()
            if connection:
                connection.close()

    def _format_products_list(self, products: List[Dict[str, Any]]) -> str:
        """格式化商品列表信息 - 修复销量和好评率显示"""
        if not products:
            return "📭 未找到相关商品信息"

        formatted = "🛍️ 为您找到以下商品：\n\n"
        for i, product in enumerate(products, 1):
            stock_status = "🟢 库存充足" if product.get('good_number', 0) > 10 else "🟡 库存紧张"

            # 修复销量显示
            sales = product.get('good_sell_num', 0)
            # 修复好评率显示（数据库存储为小数，如0.95表示95%）
            review_rate = product.get('good_positive_review_rate', 0)
            # 确保好评率正确转换为百分比
            review_percentage = review_rate * 100 if review_rate <= 1 else review_rate

            formatted += f"{i}. **{product.get('good_name', '未知商品')}**\n"
            formatted += f"   💰 价格：¥{product.get('good_sell_price', 0):.2f}\n"
            formatted += f"   📊 销量：{sales}件\n"
            formatted += f"   ⭐ 好评率：{review_percentage:.1f}%\n"
            formatted += f"   📦 库存：{product.get('good_number', 0)}件 ({stock_status})\n"
            formatted += f"   📝 描述：{product.get('good_description', '暂无详细描述')}\n"
            formatted += f"   🔗 商品ID：{product.get('good_id', '未知')}\n\n"
        return formatted

    def _detect_query_intent(self, user_query: str) -> Dict[str, Any]:
        """根据用户查询判断意图类型"""
        # 去除标点
        clean_query = re.sub(r'[？?。.，,！!]', '', user_query.strip())

        # 关键词判断：推荐类
        recommend_keywords = {'推荐', '热销', '热卖', '卖得好', '人气', '爆款', '值得买', '有什么好'}
        if any(kw in user_query for kw in recommend_keywords):
            return {'type': 'recommendation'}

        # 简短查询（1-2个词）视为品类搜索
        words = [w for w in jieba.lcut(clean_query) if len(w) > 1 and not w.isdigit()]
        if 1 <= len(words) <= 2 and len(clean_query) <= 8:
            return {'type': 'product_search', 'keywords': words}

        # 默认视为商品搜索，用原始问题作为关键词
        return {'type': 'product_search', 'keywords': [user_query]}

    def _format_single_product(self, product_info: Dict[str, Any]) -> str:
        """格式化单个商品信息"""
        if not product_info:
            return "📭 商品信息：暂无"

        stock_status = "🟢 库存充足" if product_info.get('good_number', 0) > 10 else "🟡 库存紧张"
        return f"""📦 **商品详情**：
├── 🏷️ 商品名称：{product_info.get('good_name', '未知')}
├── 💰 商品售价：¥{product_info.get('good_sell_price', 0)}
├── 📊 累计销量：{product_info.get('good_sell_num', 0)}件
├── ⭐ 好评率：{product_info.get('good_positive_review_rate', 0) * 100:.1f}%
├── 📦 当前库存：{product_info.get('good_number', 0)}件 ({stock_status})
├── 📝 商品描述：{product_info.get('good_description', '暂无详细描述')}
└── 🔗 商品ID：{product_info.get('good_id', '未知')}"""

    def _build_data_driven_prompt(self, user_query: str, intent: Dict[str, Any],
                                  products_data: List[Dict[str, Any]]) -> str:
        """构建数据驱动的提示词（优化版）"""
        if intent['type'] == 'recommendation':
            products_text = self._format_products_list(products_data)
            prompt = f"""# 角色设定
    你是「智购助手」，智能零售平台的专业导购，仅基于真实商品数据提供服务。

    # 商品数据
    {products_text}

    # 用户请求
    "{user_query}"

    # 回答要求
    1. **严格基于上述商品数据作答**：不得添加、推测或编造任何未提及的信息（如功能、参数、赠品等）。
    2. **若无商品数据**：请明确回复“📭 未找到相关商品”，并建议“尝试调整关键词、上传商品图片或联系客服”。
    3. **突出关键指标**：优先说明销量、好评率、价格和库存状态（库存 ≤10 件视为紧张）。
    4. **简洁专业+友好**：使用清晰语言，适当使用 emoji（如💰⭐📦），避免冗余寒暄。
    5. **提供行动建议**：结尾可问“需要我帮您查看详情或对比商品吗？”

    请直接给出回答，无需解释思考过程："""

        elif intent['type'] == 'category_search':
            category = intent.get('category', '相关')
            products_text = self._format_products_list(products_data)
            prompt = f"""# 角色设定
    你是「智购助手」，专业的商品导购，仅依据真实数据响应用户。

    # 查询品类
    {category}类商品

    # 商品数据
    {products_text if products_data else "📭 未找到该品类的商品"}

    # 用户问题
    "{user_query}"

    # 回答要求
    - 若找到商品：基于数据介绍各商品特点，突出价格、销量、好评率和库存。
    - 若未找到商品：明确告知“未找到{category}类商品”，并建议“尝试其他品类、上传图片或联系客服”。
    - **禁止虚构或推荐其他品类商品**。
    - 语气专业友好，可使用 emoji 增强可读性。
    - 结尾可提供进一步帮助，如“需要我推荐其他热门商品吗？”

    请直接回答："""

        elif intent['type'] == 'product_search':
            products_text = self._format_products_list(products_data)
            prompt = f"""# 角色设定
    你是「智购助手」，商品搜索专家，仅根据真实检索结果回答。

    # 搜索结果
    {products_text}

    # 用户搜索
    "{user_query}"

    # 回答要求
    1. **仅使用提供的商品信息**：不得编造参数、功能或优惠信息。
    2. **若无结果**：回复“📭 未找到匹配商品”，并建议“尝试更通用的关键词或上传商品图片”。
    3. **对比推荐**：若有多个商品，简要对比价格、销量、好评率和库存。
    4. **库存提醒**：对库存 ≤10 的商品标注“库存紧张”。
    5. **结尾引导**：如“需要了解某款商品的详情吗？如果对该产品感兴趣，请前往商品搜索页搜索商品ID了解更多详情。”

    请直接给出回答："""

        else:
            # 一般咨询或无数据情况
            products_text = self._format_products_list(products_data) if products_data else "📭 当前无相关商品数据"
            prompt = f"""# 角色设定
    你是「智购助手」，智能零售客服，基于真实数据提供购物帮助。

    # 用户问题
    "{user_query}"

    # 可用数据
    {products_text}

    # 回答要求
    - 若有商品数据：简明介绍，并关联用户问题。
    - 若无相关数据：如实说明“暂无匹配信息”，并建议“尝试具体商品名、品类或上传图片”。
    - **严禁虚构商品或功能**。
    - 保持专业、耐心、友好的语气，可适度使用 emoji。
    - 结尾可问“还有其他可以帮您的吗？”

    请直接回答："""

        return prompt

    async def chat_with_retail_context(self, user_query: str, product_info: Dict[str, Any] = None) -> AsyncGenerator[
        str, None]:
        """与AI对话，支持智能数据检索和流式输出"""
        try:
            # 如果提供了具体商品信息，直接使用
            if product_info:
                prompt = self._build_data_driven_prompt(user_query, {'type': 'specific_product'}, [product_info])
            else:
                # 智能检测意图并查询数据
                intent = self._detect_query_intent(user_query)
                if intent['type'] == 'recommendation':
                    products_data = self._query_top_selling_products(5)
                elif intent['type'] == 'category_search':
                    category = intent.get('category', '')
                    products_data = self._query_products_by_keyword(category, 5)
                # 替换原 product_search 分支
                elif intent['type'] == 'product_search':
                    # 先尝试结构化解析
                    conditions = self._parse_user_query(user_query)
                    if conditions.get('good_id') is not None:
                        # 精确ID查询
                        products_data = self._query_products_by_conditions(conditions, limit=1)
                    elif conditions.get('good_name_keywords') or any(
                            v is not None for k, v in conditions.items() if k not in ['good_id', 'original_query']):
                        # 有其他条件（库存、销量等）或关键词，用条件查询
                        products_data = self._query_products_by_conditions(conditions, limit=5)
                    else:
                        # 退化为纯关键词模糊搜索
                        keywords = intent.get('keywords', [user_query])
                        products_data = self._query_products_by_keyword(' '.join(keywords), 5)
                else:
                    products_data = []

                prompt = self._build_data_driven_prompt(user_query, intent, products_data)

            # 调用智谱AI API（流式模式）
            response = self.client.chat.completions.create(
                model="chatglm_pro",
                messages=[{"role": "user", "content": prompt}],
                stream=True,
                temperature=0.7,
                max_tokens=1024
            )

            # 流式返回响应
            for chunk in response:
                if chunk.choices and chunk.choices[0].delta.content:
                    yield chunk.choices[0].delta.content

        except zhipuai.ZhipuAIError as e:
            error_msg = f"🔧 智能助手暂时无法服务，请稍后重试。错误代码: {str(e)[:50]}"
            yield error_msg
        except Exception as e:
            error_msg = f"⚠️ 系统繁忙，请稍后再试。错误类型: {type(e).__name__}"
            yield error_msg

    async def simple_chat(self, user_query: str, product_info: Dict[str, Any] = None) -> str:
        """简化版聊天接口，支持智能数据检索（非流式）"""
        try:
            # 如果提供了具体商品信息，直接使用
            if product_info:
                prompt = self._build_data_driven_prompt(user_query, {'type': 'specific_product'}, [product_info])
            else:
                # 智能检测意图并查询数据
                intent = self._detect_query_intent(user_query)
                if intent['type'] == 'recommendation':
                    products_data = self._query_top_selling_products(5)
                elif intent['type'] == 'category_search':
                    category = intent.get('category', '')
                    products_data = self._query_products_by_keyword(category, 5)
                elif intent['type'] == 'product_search':
                    keywords = intent.get('keywords', [user_query])
                    products_data = self._query_products_by_keyword(' '.join(keywords), 5)
                else:
                    products_data = []

                prompt = self._build_data_driven_prompt(user_query, intent, products_data)

            response = self.client.chat.completions.create(
                model="chatglm_pro",
                messages=[{"role": "user", "content": prompt}],
                stream=False,
                temperature=0.7
            )
            return response.choices[0].message.content

        except zhipuai.ZhipuAIError as e:
            return f"🔧 智能助手服务暂时不可用，请稍后重试。错误: {str(e)[:100]}"
        except Exception as e:
            return f"⚠️ 系统处理异常，请稍后再试。错误: {type(e).__name__}"

    async def recognize_image_and_search(self, image_bytes: bytes) -> AsyncGenerator[str, None]:
        """修复版图片识别和搜索 - 真正的流式输出"""
        try:
            image_stream = io.BytesIO(image_bytes)
            try:
                image = Image.open(image_stream)
                image.verify()
            except Exception as e:
                yield "❌ 图片格式无效或已损坏，请重新上传清晰的图片。"
                return

            # 重置流位置
            image_stream.seek(0)
            image_data = image_stream.read()
            image_format = image.format.lower() if image.format else 'jpeg'
            image_base64 = base64.b64encode(image_data).decode('utf-8')

            # 第一步：图片识别（流式）
            messages = [
                {
                    "role": "user",
                    "content": [
                        {"type": "text",
                         "text": "请仔细分析这张图片，识别出是什么商品或产品。请用简洁的语言描述这个商品，包括它的类型、主要特征和可能的用途。"},
                        {
                            "type": "image_url",
                            "image_url": {
                                "url": f"data:image/{image_format};base64,{image_base64}"
                            }
                        }
                    ]
                }
            ]

            response = self.client.chat.completions.create(
                model="glm-4v",
                messages=messages,
                stream=True,
                max_tokens=800,
                temperature=0.7
            )

            recognition_result = ""
            for chunk in response:
                if chunk.choices and chunk.choices[0].delta.content:
                    content = chunk.choices[0].delta.content
                    recognition_result += content
                    yield content

            # 第二步：基于识别结果搜索商品
            if recognition_result.strip():
                yield "\n\n🔍 正在为您搜索相关商品...\n\n"

                # 提取关键词进行搜索
                keywords = self._extract_keywords_from_recognition(recognition_result)
                search_query = ' '.join(keywords) if keywords else recognition_result.strip()

                if search_query:
                    # 使用现有的商品搜索逻辑
                    products_data = self._query_products_by_keyword(search_query, 5)

                    if products_data:
                        # 格式化商品信息（修复销量和好评率显示）
                        products_text = self._format_products_list(products_data)

                        # 构建智能回复提示
                        prompt = f"""基于图片识别结果"{recognition_result}"，为用户推荐以下商品：

    {products_text}

    请用友好的语气向用户介绍这些商品，突出与图片识别结果的关联性。
    注意：不要在回复中重复商品列表信息，直接基于商品数据进行推荐说明。
    结尾提示：如果对该产品感兴趣，请前往商品搜索页搜索商品ID了解更多详情。
    保持简洁专业，不要重复信息。"""

                        # 调用AI生成回复（流式）
                        ai_response = self.client.chat.completions.create(
                            model="chatglm_pro",
                            messages=[{"role": "user", "content": prompt}],
                            stream=True,
                            temperature=0.7,
                            max_tokens=600
                        )

                        # 流式返回AI回复
                        for chunk in ai_response:
                            if chunk.choices and chunk.choices[0].delta.content:
                                yield chunk.choices[0].delta.content
                    else:
                        yield "\n😔 抱歉，没有找到与图片相关的商品。请尝试上传更清晰的图片或描述您需要的商品。"
                else:
                    yield "\n⚠️ 无法从图片中提取有效的商品信息，请尝试上传更清晰的商品图片。"
            else:
                yield "\n❌ 图片识别失败，请重新上传清晰的商品图片。"

        except Exception as e:
            print(f"图片识别错误: {e}")
            yield f"❌ 图片处理失败，请稍后重试。错误: {str(e)}"

    def _extract_keywords_from_recognition(self, recognition_text: str) -> List[str]:
        """从图片识别结果中提取商品搜索关键词"""

        # 增强品类关键词库
        product_keywords = {
            '手机': ['手机', '智能手机', 'iPhone', '华为', '小米', '荣耀', 'OPPO', 'vivo', '三星'],
            '电脑': ['笔记本', '台式机', 'PC', '电脑', '笔记本电脑', '游戏本', 'MacBook'],
            '路由器': ['路由器', 'WiFi', '无线网', '网络设备', '无线路由器'],
            '扫地机器人': ['扫地机', '机器人', '自动清洁', '扫地', '扫地机器人', '清洁机器人'],
            '耳机': ['耳机', '蓝牙耳机', '头戴式', '无线耳机', '耳麦', 'AirPods'],
            '电视': ['电视', '显示器', '屏幕', '智能电视', '液晶电视', 'LED电视'],
            '电动牙刷': ['牙刷', '电动牙刷', '声波牙刷', '口腔护理'],
            '保温杯': ['保温杯', '水杯', '杯子', '热水杯', '茶杯'],
            '键盘': ['键盘', '机械键盘', '无线键盘', '电脑键盘'],
            '鼠标': ['鼠标', '无线鼠标', '游戏鼠标', '蓝牙鼠标'],
            '摄像头': ['摄像头', '监控', '网络摄像头', '智能摄像头'],
            '音箱': ['音箱', '蓝牙音箱', '智能音箱', '音响'],
            '手表': ['手表', '智能手表', '手环', 'Apple Watch'],
            '平板': ['平板', '平板电脑', 'iPad', '华为平板'],
            '充电器': ['充电器', '快充', '充电头', '数据线'],
            '打印机': ['打印机', '打印设备', '激光打印机'],
        }

        matched_categories = []
        for cat, words in product_keywords.items():
            if any(word in recognition_text for word in words):
                matched_categories.append(cat)

        # 使用 jieba 分词提取关键词
        words = jieba.lcut(recognition_text)

        # 增强停用词过滤
        stop_words = {
            '的', '了', '吗', '呢', '吧', '请', '一下', '这款', '这个', '那个', '是', '有',
            '一个', '一款', '用于', '适合', '可以', '使用', '白色', '黑色', '红色', '蓝色',
            '新款', '产品', '设备', '东西', '物品', '看起来', '显示', '图像', '图片', '图中',
            '这', '该', '其', '它', '可能', '应该', '一些', '一种', '非常', '比较', '相当'
        }

        # 提取有效关键词
        candidates = [
            w.strip() for w in words
            if len(w.strip()) > 1
               and not w.isdigit()
               and w not in stop_words
               and not re.match(r'^[a-zA-Z]+$', w)
        ]

        # 合并品类关键词和分词结果
        all_keywords = matched_categories + candidates

        # 去重并限制数量
        seen = set()
        filtered = []
        for w in all_keywords:
            if w not in seen and len(filtered) < 5:  # 最多5个关键词
                filtered.append(w)
                seen.add(w)

        return filtered

    def validate_api_key(self) -> bool:
        """验证API密钥是否有效"""
        try:
            test_response = self.client.chat.completions.create(
                model="chatglm_pro",
                messages=[{"role": "user", "content": "测试连接"}],
                max_tokens=5
            )
            return True
        except Exception:
            return False
